Welcome to NetBots 2.0

"these are the droids you're looking for"

NetBots is a program that lets you send out virtual "agents" over the Internet. You can use NetBots to check for web page updates, keep a PPP connection alive, monitor a remote host, and much more. This document will tell you how to use NetBots effectively, answer some common questions, take you through a brief tutorial, and explain how you can register NetBots to get even more features! Additional information and updates can be found at the NetBots web page: http://www.printerport.com/klephacks/netbots.html

Table of Contents

Introduction

NetBots is a program that lets you send virtual helper robots out on the Internet. Version 2.0 has four types of bots that are fully customizable. With NetBots, you can have a bot tell you when a web page has been updated, you can be notified when a user logs into their UNIX account, you can find out the instant an Internet host goes offline, and much more. When a bot obtains this information, you can have an alert displayed, sound an alarm, send a message to your pager, fire off an email, or just about anything.

Since NetBots is fully customizable and works with the Internet at a fairly low level, it can very easily be used incorrectly or even illegally. If you're not familiar with how TCP/IP works, please read this entire document before using NetBots. You'll be glad that you did!

Requirements

NetBots requires is a Mac running System 7 or later with a TCP/IP connection (PPP or SLIP is perfectly fine) and the Thread Manager (recent versions of MacOS have it built in). NetBots contains native code for both MacTCP and Open Transport. It should work well under both networking architectures. The PowerMac version of NetBots requires the "ObjectSupportLib" shared library, which is part of System 7.5 and later. The real requirements have to do with the user:

  1. You should be somewhat familiar with how the Internet works
  2. You should know about TCP/IP or you should read the guide below.
  3. You should NOT use NetBots maliciously or to spy on people. If you're unsure, read the Morality and Legality section.

Quick Start

If you're an internet novice (here's a good test: If you know what TCP/IP stands for, you're not a novice), you should not jump right into using NetBots. Rather, novices should start with the TCP/IP Tutorial. This Quick Start is meant for people that know about TCP/IP ports. If you read this section, please also read the Morality and Legality section before using NetBots.

  1. Launch NetBots by double-clicking on the icon
  2. Send a new bot by selecting an item from the "Bot" menu
  3. Your bot will be added to the bot list, which runs every 2 minutes (starting now!)
  4. You can run your bot at any time by selecting "Run Now" from the "Bot" menu
  5. You can change the delay time by selecting "Preferences" from the "Edit" menu
  6. You can get rid of all the existing bots by selecting "Delete All" from the "Bot" menu

Those are the basics. Of course, since the uses of NetBots are infinite, there's a lot more to learn. The above should get you started, but please consult this documentation eventually.

What's New in 2.0

Version 2.0 of NetBots is a complete rewrite with many new features that will be immediately obvious to users of earlier versions. Among the more noticable ones:

TCP/IP Tutorial

TCP/IP sounds scarier than it really is. It's basically just a set of rules that computers follow to communicate over the internet. If you must know, it stands for "Transmission Control Protocol/Internet Protocol," which is a tragically ambiguous acronym.

TCP and IP are actually two different protocols. NetBots tends to stick to TCP, but future Bots may take advantage of some of the features that IP offers. The only real difference is that TCP works by establishing a connection between two computers and sending and receiving data. IP works a little differently -- the connection is less defined and the data can arrive in any order or even get lost! As you can probably guess, people prefer TCP.

So, now that we've limited our focus to TCP, it should be a bit less scary. We can easily explore some of the properties of TCP without getting too far into the details. At its highest level, TCP allows two computers to communicate. How does it do this? Here are the steps it takes:

  1. Establish a Connection on a Port - When you use TCP to connect to another computer (for example, to view a web page), TCP attempts to connect to the computer. You might notice a problem with this. What if the other computer (known as the "remote computer") is both a web server and an FTP server? How does TCP tell the other computer to connect to the web site? In fact, TCP uses a pretty clever technique for doing this. When it connects to the remote computer, it connects to a specific "port." Ports are just a number that the two computers agree upon so they know what to send. For example, most web servers run on port 80. When you use a browser like Netscape to view a web page, Netscape says to the remote computer "May I connect on port 80?" The other computer responds "Port 80 -- that's my web server! Go ahead and connect!" So, as you can see, ports are just a number that the two computers agree on. As I mentioned, most web servers run on port 80. The popular program "finger" generally runs on port 79. When you telnet into a host, you use port 23. Ports are pretty important in NetBots, so be sure you understand them!
  2. Send Some Data - Continuing our example from above, our web browser has established a connection with some web site. That's all fine and good but how does the web server know which page we want to see? Netscape has to send some data (the location of the page) to the remote computer so the remote computer can send the page. In web lingo, what Netscape actually says is usually something like "GET /index.html\r\n". The GET just tells the web server that we're trying to get a page. The /index.html is the page we're trying to get and \r\n is a terminator, which tells the web server "that's it!"
  3. Read Some Data - Okay, now the web server knows that we want a particular page. So our computer basically starts reading whatever data the web server sends. In the case of Netscape, the data will be put on the screen for us to look at. NetBots does something a bit different with the data -- it analyzes it. You'll see some examples of how NetBots analyzes the data below.
  4. Close the Connection - Once we have all the data we want, we need to close the connection to the remote computer so that others can connect.

So that's your basic TCP connection scheme. It may sound over-simplified, but it's really not. This is pretty much the way that all web servers, ftp servers, finger servers, and lots of other servers work. They really only differ in which port they use and what type of data they send and receive.

Now that you've been through this brief tutorial, you should have a better idea of how the Internet works. NetBots is heavily based on the concept of TCP ports and sending and receiving data so remember these concepts and enjoy NetBots!

PortBots

The PortBot is one of the most flexible NetBots. Since PortBots work on a very low level, novices might want to stick to PingBots, FingerBots, and WWWBots. PortBots can be very dangerous. When misused, they can confuse or even slow down Internet hosts. That said, PortBots are also very powerful. You can use a PortBot to access the web, or just about any Internet service.

PortBots allow you to send any string of text to any TCP/IP port of any Internet host. Each time the bot runs, it will search for a key phrase in the text it receives from the host. If it finds a match, it lets you know. If not, it keeps searching. In version 2.0, you can even tell a PortBot to look for the absence of a string. So you can now continue to look for a phrase and as long as it's there, the bot will continue to run. As soon as it disappears, the bot will alert you. This can be useful for finding out when someone reads there mail, or when some sort of condition changes.

When you select "New PortBot" from the "Bot" menu, you are prompted for the following information:

Host: This is the Internet host you're going to connect to. NetBots accepts standard host names (like "www.printerport.com") as well as dotted-decimal IP addresses (like "129.21.203.3").

Connect to Port: This is the TCP/IP port you're going to connect to. Some of the popular services are listed in the popup menu next to the port field. This is an example of where one can make mistakes. NetBots allows you to attempt to connect to any port. You can put in ports that don't exist. If you're lucky, you'll get an error message. If you're unlucky, you might end up with a bot that runs forever. It's a good idea to stick to known ports, like the ones listed. The most popular of those are Finger (79) and HTTP (80).

Send String: This is the string of text you're going to send to the host. This string can include the special characters \r, \n, and \t, which are carriage return, newline, and tab respectively. The "send string" will vary based on which TCP service you are using. For finger, you'll generally send a username. For HTTP, you'll generally send a HEAD or GET command. Please see the appropriate Internet RFC's for more information on the service you are interested in.

Search String: This is the string that you are waiting to either appear or disappear. This is where you get creative. For example, you could run a PortBot that runs on port 79 (finger) and looks for the string "New mail". On most UNIX hosts, this would let you know when you have new mail. The bot would keep running until it found that string, so you'd know the instant you got a new mail message. Conversely, you could look for the absence of the string "New mail" so the bot would alert you when the user has read their mail. More examples of how to use PortBots creatively are found in the Sample Usage section.

Append CRLF: This box should usually be checked. This is very important! Most TCP network services require that all requests end in a UNIX-style carriage-return linefeed sequence. NetBots will automatically append these characters if you leave this box checked. Only uncheck it if you're sure you know what you're doing.

Retire after first success: Leave this box checked if you want the Bot to automatically retire after it detects the presence or absence of the string (it will remain in the bot manager until a "success"). Be warned that if this box is not checked, the Bot will never die out automatically. It will just let you know every single time it finds your search string.

Search for Presence/Absence: Use these radio buttons to choose whether this bot is successful when it finds the given search string or when it doesn't find the given search string. Most of the time, you'll look for the presence of a string. However, there are several applications of the absence option.

Script or Alert text: There are four ways that "successful" bots can let you know of their success. You can choose between these options from the preferences dialog. The first, which will be familiar to users of NetBots 1.x, is to display an alert. If you select this method, whatever text you enter in the "Script or Alert text" field will be displayed as a notification when the bot reports a success. The second method is execute an AppleScript. In that case, whatever text you put in this field will be compiled and executed as a regular AppleScript. This enables some really cool stuff so please see below for more information. The other two ways are to beep or do nothing. Those are noticably less exciting.

FingerBots

FingerBots let you repeatedly check if a person is logged onto their Internet account. FingerBots are designed to work exclusively with UNIX-like and VMS hosts. If FingerBots don't seem to work on a certain user, their host may not be running a finger server. Some system administrators consider it a security measure not to include logon information through finger so FingerBots may not work on some hosts. Check the Common Problems section for solutions.

FingerBots are pretty easy to use. You select "New FingerBot" from the "Bot" menu, then enter the person's email address in the fields. Most hosts are UNIX, but if you know that the person has a VMS account, you can specify that. The Alert Text field allows you to customize how you will be notified when the user logs on. This can be either a message (displayed in an alert) or an AppleScript (see below). When you click "OK", the bot is added to the bot manager.

NetBots pauses two minutes between runs by default. You can customize this delay by selecting "Preferences" from the "Edit" menu. The first run will be immediately after the first bot is added to the bot manager. When a FingerBot has a successful run (i.e. the user has logged on), it self-destructs (by removing itself from the bot manager and not running anymore) and will either notify you or run the script you provided.

It's worth noting that FingerBots are not fool-proof. You can easily trick a FingerBot by putting the phrase "On since" somewhere in your .plan file (the file that UNIX displays when you finger a user). However, it's very unlikely that you would encounter such a case.

PingBots

PingBots notify you when an Internet host goes offline or comes online. This is useful if you are in charge of a remote system (like I am) and need to know when it crashes.

PingBots aren't really a true implementation of what's commonly referred to as "ping". Instead, they just try to connect to a certain port of a host. NetBots uses port 79 (finger) by default, but you can change it to your taste. Any open port will do. Port 79 is usually open on most UNIX hosts. In contrast, most Macs have no open ports, so PingBots won't work. If the Mac in question is a web server, use port 80. If it's an FTP server, use port 21.

To send a PingBot, select "New PingBot" from the "Bot" menu. Enter the hostname (regular or dotted-decimal) and any open port. If you choose "Check for down", the PingBot will let you know when the host goes down. If you select "Check for up", the PingBot will let you know when the host comes back online. The Alert Text field allows you to customize how you will be notified when host comes up or goest down. This can be either a message (displayed in an alert) or an AppleScript (see below). When you click "OK", the bot is added to the bot manager.

The PingBot will run, along with the rest of the bots in the bot manager, every two minutes by default. You can change this by selecting "Preferences" from the "Edit" menu. PingBots are set to determine if a host is up or down by trying to connect for up to about 30 seconds. If that amount of time goes by and no connection has been established, the PortBot assumes the host is down.

WWWBots

WWWBots are the hip new bots in version 2.0. They let you find out when a web page has been changed - a capability of great benefit to webmasters and casual surfers alike.

To send a WWWBot, select "New WWWBot" from the "Bot" menu. Type a standard URL in the URL field. NetBots accepts any normal HTTP URL and you can leave out the http:// part of the URL if you desire. If you want the WWWBot to be successful each time the page is updated (as opposed to only the first time), uncheck the retire after first success checkbox. Put the text you'd like to be alerted with or the AppleScript you'd like to run in the large field at the bottom. More information about scripting can be found below. By default, NetBots will just display whatever message you type here when the bot is successful. Click "OK" to add the bot to the list.

An important aspect of the WWWBot is what it does each time it runs. The first time a WWWBot runs, it looks for a file called "robots.txt" on the host's machine. This file is a standard format that tells Internet robots which pages they have access to. NetBots adheres to this standard and will refuse to look at a page if it is excluded. The second time the bot runs, it calculates a checksum over the page. Every subsequent time, it calculates the same checksum and compares it to the original. If there's a descrepency, the bot decides that the page has changed. I should point out that the checksum is not foolproof. If you change a single character on a page, there's a change that the WWWBot won't notice. This sacrifice was made at the cost of speed an efficiency. I experimented with several methods and determined that a checksum was the best.

Bot Management

NetBots 2.0 includes several new features to make the management of bots easier. The bot manager is a window that contains a hierarchical list of all the bots that currently exist. Bots that are disabled are shown with perentheses around their names. You can disable a bot by unchecking the "activated" checkbox in the bot's program window.

Speaking of which, you can edit any bot (as long as it's not running) by double-clicking its name in the bot manager window. You can also remove any bot by highlighting it and pressing the delete key on your keyboard. You cannot delete bots that are currently running.

NetBots 2.0 will remember all of the bots listed in the bot manager when the program quits. The next time the program is run, all of the enabled bots will run immediately and then begin their normal cycles. If you do not want a bot to run when the application is started, you may wish to deactivate it from its program window.

Adding to the flexibility of NetBots, the bot manager window can be hidden, grown, shrunken, and scrolled. In fact, it even supports live scrolling of the list. Thanks, PowerPlant!

Preferences

The NetBots preferences settings let you customize the way that NetBots works. There are several areas that you can control, each represented by a separate tab in the preferences window.

General

Reporting

Sample Usage

Here are some interesting and creative ways you can use NetBots:

System Administration

Web traffic monitor - If you run a web server but you're unsure if you can handle all the accesses you're getting, try running a PingBot on port 80. Select "check for down" and you'll be notified if NetBots was unable to establish a connection to your web server.

ISP connection saver - Many ISP's have begun a policy of disconneting users who don't send packets within a certain amount of time. Some strange/braindamaged modems might even disconnect you if you don't send anything for a long time and line noise interferes. To avoid this, many people have used NetBots to keep their connection alive by sending PingBots to hosts that they know are up. In theory, this should keep your connection going. Some ISP's may forbid this type of behavior so please consult them first and only use this technique if you actually need to keep the connection alive.

Hit generator - This is an example of NetBots use that's kind of on the fringe. You could have a PortBot run on port 80 that just gets a web page and doesn't look for anything in particular. It would run over and over, continually adding hits to the page, artificially pumping up the page's statistics. I would definitely not recommend this as a way to make it look like you have more visitors than you really do (there are ways that people can figure out that your numbers are fake), but if you were testing your hit counter or wanted to begin your counter at a certain number, NetBots might be a good way to do it.

Single Run

Single-run bots - While the idea of NetBots is to run them repeatedly until something changes, it can be useful to run them a single time. For example, if you wanted to know if your name was on a particular web page, but the page was long and you didn't want to run Netscape, just run a PortBot on port 80 and send a "GET" command to the webserver followed by the path. Include your name in the search field and see if it alerts you the first time through.

Last modified - Sometimes when you upload a web page to your web server you may forget to name the file correctly or may upload the wrong version. If you send a WWWBot before uploading and send it again afterwards, you can make sure that the change has been made. Note that the first time the WWWBot runs, it just checks for /robots.txt, so you actually need to run it three times.

Monitoring

Check for web page updates - The new WWWBot greatly simplifies this task and you can now do such studly things as telling Netscape to reload a page when it changes or sending email to a group of friends when stocks reach a certain level.

A better BIFF - biff is the UNIX program that lets you know when new mail arrives. If your telnet window is in the background, you might not notice however. Instead, you can run a PortBot on port 79 (finger) that looks for the string "New mail". Most UNIX hosts put "New mail received ...." in your finger information when you have new mail.

A talk assistant - This is why I originally started NetBots. If you want to talk to somebody over the Internet using a program like ytalk for UNIX or talk for the Mac, you want to know when they log in. Instead of fingering them every few minutes, I just run a FingerBot and I'm notified when they log on.

Web site ping - Here's a good one. If you want to get on a web site, but it's busy, just run a PingBot on port 80 with a simple script telling Netscape to load the page. Go on with your work/surfing and when the site is available, Netscape will just go ahead and load it.

Scripting with NetBots 2.0

NetBots 2.0 allows unlimited customization through AppleScript, a very cool way that applications can talk to each other. I should point out right away that NetBots 2.0 itself is not scriptable though it does support the open and quit messages. There simply wasn't enough time to include scripting in this version.

However, while NetBots isn't scriptable, you can use NetBots to execute scripts when a bot is successful. This is far more powerful than the former and is really a great new feature. The classic example is the WWWBot. You can include a small script with a WWWBot that tells Netscape to load the URL. So when the page changes, Netscape will automatically get the message and load it. Another classic that users have been asking for for a long time is that you can send a PingBot that will automatically notify your pager software (and send you a page) when a site goes down.

Important Note! If you use NetBots to talk to applications that aren't currently running, it may ask you to locate the application the first time it is successful. This is just the way AppleScript works but could be annoying if you're not around. To avoid this problem, make sure you use the exact name of the application and leave it running if possible.

Scripts in NetBots are no different from any other AppleScript except that they don't report errors and are limited to 255 characters of text. For these reasons, I suggest you try out your scripts in another script editor first and paste them into the NetBots program window when you know that they work. If you're unfamiliar with AppleScript, please check out any of the excellent books on scripting or look over the examples below to get an idea of how it works.

Examples

1) The classic WWWBot. This script will make Netscape load the KlepHacks web page. You'd include this script with a WWWBot that figures out when the said page is updated.

tell application "Netscape Navigator™ 3.0.1"
OpenURL "http://www.printerport.com/klephacks/"
activate
end tell

2) The classic PingBot. This script will tell the popular pager program PageNOW! to send a message to Gwen's pager.

tell application "PageNOW!"
send page "The server is down!" to "Gwen"
end tell

If you have a clever use of scripting with NetBots, please send email to <klephacks@kagi.com> and we'll gladly add your script along with your name to the NetBots FAQ.

Technical Details

NetBots 2.0 was written in C++ using Metrowerks PowerPlant. NetBots 2.0 was a total rewrite of the old program and includes many new features. Let me just say how much this code rocks. Everything is incredibly clean and the interface for bots is so well-defined that it probably won't be very difficult to accept plugins at some point in the future. Because NetBots is totally object-oriented, future development will be relatively easy. I hope to add a lot more types of bots, depending on user feedback so please send your ideas to <klephacks@kagi.com>

For version 1.0 , I used Simple Sockets, the excellent sockets library by Michael Trent. Simple Sockets allowed me to use some of the code that I had already written in UNIX. Michael was also very helpful when I was just getting started with NetBots. After struggling with Open Transport and MacTCP for several days, Simple Sockets made it possible to actually establish a connection. For version 1.1, I ported all of the low-level code from Simple Sockets to PowerPlant. The advantage of using PowerPlant (besides being more widely supported) is that it contains native code for both MacTCP and Open Transport. While PowerPlant Networking is far more complicated than Simple Sockets, I think it's a great accomplishment to have NetBots working on both MacTCP and Open Transport. Version 2.0 also uses the PowerPlant networking classes, but since Metrowerks dropped support for the event loop classes, I was forced to make this version threaded, which had the upshot of making the program much cooler.

The AppleScript support is very minimal but should be fine for most uses. NetBots will compile and run anything that AppleScript can but does not report errors in your code or make any indication that the script ran successfully. Future version may enhance AppleScript capabilities and add support for Frontier if there's a demand.

Support for the /robots.txt file is new in version 2.0. I went by the spec pretty strictly. If you want to disable NetBots from your site, you can refer to it with the * or by name, netbots. NetBots doesn't check individual directories for robots.txt, but will always check the root directory. Checking individual directories is optional according to the official spec.

Here's some other miscellaneous technical information: The default memory partition should be fine for the shareware version since it places a limitation on the number of bots (the registered version allows an infinite number of bots as long as there's enough memory and TCP ports open). The bots are truly threaded and if you watch the status indicator closely, you'll see the numbers change as bots are sent and come back in. The RegisterBot pops up occassionally to remind you that you're using shareware. To disable it, see the Registering NetBots section. Much of the interface was designed by Darien Kruss, and some of the graphics were done by Dave Laster.

Morality and Legality Issues

This is important. Before I even started writing NetBots, I was worried about potential problems with legal and moral issues. You must be very careful with how you use NetBots. You are responsible for any misuse. Please read this guide to avoid getting into trouble.

First off, most Internet admins won't notice if you're running NetBots on their site. Still, you should ask first if you're going to be running it for an extended period of time or in a way that seems questionable. Running a FingerBot every 20 minutes for a few hours probably isn't a problem. However, some admins are picky about any sort of automated client running on their machine. This is precisely why NetBots doesn't allow you to run the queue more than every two minutes. I don't think anybody should have a problem with this, but again, you are responsible for your own actions. If you are asked to stop, then stop. If you're unsure about a bot you're about to send, ask the admin first.

Since people have asked, I'll confess to exactly why I wrote NetBots. The primary reason was that I was writing a finger client for the BeBox anyway so it was relatively easy to port the BeOS code to UNIX (and later to the Mac). But another reason was that at the time, I had a friend across the country who I used to talk to using the UNIX "ytalk" program. I wanted to talk to this particular person as soon as she logged onto her UNIX account so I would continually finger her account until I could see that she was online. After I ported the BeBox finger client to UNIX, I modified it so it would finger an account continually (with no pauses) and let me know when she logged on. I didn't get in any trouble for doing this, but I really should've had the program wait about 5 minutes between attempts. Anyways, the entire thing was fairly harmless because the person on the other end actually wanted me to page her when she was online. Maybe you see what I'm getting at -- NetBots could be used easily to harass another individual. Don't. You can really get in a lot of trouble for doing that. In general, a note from one Internet admin to another is all it takes to get you kicked off. Plus there are laws against it. If you use NetBots to stalk someone who doesn't want to talk to you and doesn't want you spying on them, you can get into some serious trouble.

NetBots 2.0's WWWBot checks a file called robots.txt the first time it runs. If you manually use a PortBot to do stuff on the web, you should check this file manually to make sure the site allowed automated clients. More information is available at the following URL:

http://info.webcrawler.com/mak/projects/robots/robots.html

Most of the harm that NetBots can do is only in using up CPU time by repeatedly sending requests on ports. On most modern computers, this isn't a problem and NetBots won't use up many resources. There's nothing you can do with NetBots that you couldn't do manually, so obey the same laws. Just because a bot is doing something, doesn't mean it's not illegal and certainly doesn't mean it can't be traced back to you. Use NetBots to help manage your sites and to locate users. Don't use it to spy on people or attempt to break into systems. It will get you in trouble and it's not even all that great for those purposes. Remember: respect the wishes of Internet admins and be very careful with NetBots.

Common Problems Experienced

NetBots doesn't seem to work on my machine

Make sure that you have established a TCP/IP connection. NetBots will attempt to establish one if you're not connected, but if your connection is up but unreliable, NetBots may hang, pause, or quit. Also, you'll need the thread manager installed (it's built into recent versions of Mac OS).

If NetBots seems to quit suddenly, try giving it more memory in the Finder. Also, be sure you're running it off a hard drive on System 7 or later.

I search for a string using a PortBot or FingerBot and it's not found even though I know it's there

There are a few ways that a PortBot or FingerBot can be tricked. For one thing, PortBots are case-sensitive. The case must match for the string to be found. Also, the string you send to a PortBot must be terminated appropriately! By default, NetBots does this for you by appending \r\n. Only override this option if you know what you're doing.

WWWBots don't detect a change to my web page

To speed things up, WWWBots run a checksum over a page to summarize the page with a single number. When there's a change to the page, the checksum should also change. However, there's an outside chance that making a change to a web page won't affect the checksum. This is pretty rare but if you're having this problem, this could be the reason.

WWWBots seem to take too long and cause a brief pause

When I first wrote the WWWBot, I tried to detect changes by looking at the page's "Last Modified" line in the header. Over time, I found out that some web servers (like Microsoft's) don't comply with this standard and have no such field. So it became necessary to somehow store the entire page. What that comes down to is that each time a WWWBot runs, NetBots has to examine the entire page and find out if there are any changes. This is no problem for most web pages, but if the page is long, there might be a slight pause. Future versions of NetBots may allow you to manually override this method and use the header instead.

FingerBots don't seem to work on some users

Time for a quick explanation of how FingerBots work. When I'm logged onto my UNIX account at Stanford's computer science department, fingering me would return something like this:

[xenon.Stanford.EDU]
Login name: klep                        In real life: Scott Kleper
Directory: /u/klep                      Shell: /bin/tcsh
On since Oct 12 20:47:02 on pts/40 from klepland.Stanford.EDU
39 seconds Idle Time
No unread mail
No Plan.
 

You can tell that I'm online because one line says "On since". FingerBots are really PortBots that look for the string "On since" when fingering a user. Most UNIX-like hosts return "On since" when a user is online. Many schools and organizations still use VMS instead of UNIX, which does not do this. Even some versions of UNIX don't comply with this method. For those, you'll have to use a PortBot accordingly. In some cases, even a PortBot won't work. For those of you using VMS, NetBots now supports a reliable method for running FingerBots which can be selected when you create a FingerBot.

Questions and Answers

Q: Who are you?

A: My name is Scott J. Kleper. I'm a sophomore at Stanford University, originally from Pittsford, New York. I'm 19 years old and I've been programming Macs for about five years. I've been writing shareware for almost as long. My other programs include MacFolklore II, HTML Markdown, HTML Markup, Jot, and PowerSpaceTabsPlus. All are available from the KlepHacks Shareware home page at <http://www.printerport.com/klephacks/ >. More information about me can be found below or at my personal home page.


Q: Why did you write NetBots?

A: During the 95-96 school year, I was fortunate enough to have an internship at Be, Inc. in Menlo Park, CA. One of my projects was to write a Finger client for the BeBox. Since BeOS is POSIX-compliant, I developed the program concurrently for UNIX and BeOS. When I was done, I modified the UNIX version to analyze the data that was returned so I could be notified when a user logged on. As I started to think of similar programs that I'd like to write, I decided to unify them as NetBots. Okay, I also wrote it so I could find out when my then-girlfriend was online and could talk to her.


Q: Are there any similar programs?

A: Not really (at least not that I've seen). I have a theory why -- in the past, most people who were on the Internet were UNIX folks. To them, NetBots would seem pretty trivial. They could write UNIX shell scripts that would do most of the same tasks (without the cool interface). However, with the growth or SLIP/PPP accounts and the recent explosion of the Internet, UNIX and Internet are no longer synonymous. People are using Macs on the Net and NetBots is the most elegant solution I've seen for repeated connections.


Q: How much trouble can I get in for using this?

A: None if you use it correctly. NetBots doesn't do anything that you couldn't do yourself from a UNIX prompt. NetBots just automates it and makes it repetitive. Some admins get nervous about any sort of automated "robot" connecting to their site repeatedly. But since you can't connect more often than once every 2 minutes, you should be fine. As a disclaimer, you are responsible for how you use NetBots.

On the flip side, you could conceivably get into plenty of trouble. Losing your Internet account is probably the first thing that would happen. Abusers of NetBots and similar programs could find themselves slapped with fines and charged with crimes. This is not meant to discourage you from using NetBots, but it is meant to discourage you from using it illegally.


Q: Why aren't there other kinds of Bots?

A: NetBots was developed as a fully object-oriented program. To the user, this probably means nothing. But to a programmer, this means that I can easily add new Bots to the existing front end. It also means that I can easily modify the interface and keep the program the same. These are good things. I won't commit to developing future versions, but I will say that it's very likely. Some of the features I'd like to include in the future are:

Q: Why do you tout the scriptibility of NetBots when it's not scriptable?

A: NetBots 2.0 lets you run AppleScripts when bots are successful. This is an extremely powerful feature with some great applications. NetBots itself supports basic scripting commands like open and quit. The application itself is not scriptable mainly because I didn't have time to add scripting in this version. I think sending AppleScripts is much more important but making NetBots scriptable is definitely doable.

Q: Where's support for other new Apple technologies?

A: There were plans for an OpenDoc version but that's extremely unlikely now. A Rhapsody version would rock and would be pretty easy to write. As soon as I get Rhapsody, I'll decide which of my shareware programs to port and I'll probably come up with some new programs to write. If there's some other technology you want me to support, send email to klephacks@kagi.com


Q: I work for a user group, CD-ROM publisher, or magazine. Can we give out your program?

A: If you're going to be distributing it electronically or on disk, you may distribute NetBots 2.0 without notifying me. However, I still request that you send me a quick note letting me know where it's going to be distributed. If you are going to write an article or review of NetBots, I really really really want to read it. Please please please send me a copy of the article. If you're going to be distributing NetBots 2.0 on a CD-ROM, you must notify me first. I will generally grant permission for distribution, but I want to know which CD it's going to be on. Send permission requests, reviews, etc. to:

Scott J. Kleper
Attn: NetBots 2.0
klephacks@kagi.com
134 Caversham Woods
Pittsford, NY 14534-2834
USA


Q: I want to learn more about TCP/IP programming in general. Where can I look?

A: I highly recommend PowerPlant for writing net-related programs. They have some great new classes over the Networking classes that abstract away a lot of the scary stuff. The best online resource for Macintosh network programming is the Macintosh TCP/IP Programmer's Guide.


Q: Why does this "Register Bot" come up randomly? Just to annoy me into giving you money?

A: The RegisterBot is not intended to annoy you. The reason I have the RegisterBot is just to remind you that the program you're using is shareware. Writing software is one of my favorite hobbies and I love getting feedback from users who have used my programs to save time. But software development is time-consuming and expensive, especially for a kid trying to work his way through college. All I ask is that if you use NetBots more than a couple of times, you register as described in the Registering NetBots section.


Q: Can I have the source code so I can write my own version of NetBots?

A: No. NetBots 2.0 is a copyrighted product and I will not release the source code. However, I am sympathetic towards other people working on similar projects and I'd be happy to discuss techniques or provide help with your program. Send me email. If you're interested in writing a similar program from scratch and you're familiar with the UNIX socket interface, you might want to try Simple Sockets, the socket package I used in version 1.0. If you're a little more network-savvy (or C++ savvy) and you want native OT code, the PowerPlant networking classes are quite good.

Registering NetBots

Writing shareware is a lot of work, especially for a college student. Considering all the time that NetBots can save you, I request that if you find it useful, you pay your shareware fee.

If you do decide to register NetBots, you will receive the registered version, which will allow you to add as many bots to the queue as memory and TCP permits. It will also disable the RegisterBot.

Registration costs $15 for a single-user license. This means that one person can use NetBots on one Macintosh. If you're in a multi-user environment, or want to have NetBots installed on multiple machines, you may purchase multiple licenses at $15 each. Site licenses are also available.

The preferred way of registering is to send me a check directly. Please include your email address with your registration so I can send you the latest version right away. Make your $15 check payable to "Scott J. Kleper" and please include your email address if possible. I can also take traveler's cheques, money orders, and international money orders in US dollars.
Send checks to:

Scott J. Kleper
Attn: NetBots 2.0
134 Caversham Woods
Pittsford, NY 14534-2834
USA

The alternate way of paying is through the Kagi shareware payment service. Paying through Kagi allows you to use a check, credit card, or electronic payment. To register through Kagi, just double-click the "Register KlepHacks" program that came with NetBots. If you didn't get the Register program when you downloaded it, it is available from:

ftp://htc.rit.edu/pub/register-klephacks.hqx

You can also register on the web through Kagi, which is something new. You have to pay by credit card if you use this method, but it's quick and easy. Just go to the KlepHacks Register Page for more information. A secure connection is available.

The register program is pretty easy to use, but if you need help, please read the "KlepHacks Register Help" file. Again, please include your email address so that I can send the registered version to you as quickly as possible.

One last thing about registering. I really appreciate it when people send comments about and suggestions for the program. I read them all and if you supply an email address, I'll probably contact you. If you use the Kagi method, you can still send comments.

About the Author

[Disclaimer: This is probably more than you wanted to know.]

I was born on 7/2/77 in Rochester, NY. I got my first Mac on 9/13/91. Nothing in between really matters. Just kidding. I actually did quite a bit of computer stuff as a kid. My father, who has been interested in printing all of his life, made the transition to electronic publishing rather early so we always had several computers around our house even in the early 80's. My dad actually invented some way to connect Apple II's to typesetters, but to this day I have no idea exactly what it did. I used to take classes at the Rochester Museum and Science Center, where I would learn useless things like SuperPILOT and BASIC. As a 7 year-old BASIC programmer, I used to write out adventure games on little pads of paper and type them in whenever I got a chance. It was fun to give them to other kids and see if they could solve the mystery, but I still have nightmares about GOTO's.

Around 4th grade, I finally got my own Apple (I think it was a //+). By then I was known as the computer kid at school and I continued to write games in BASIC. My odd fascination with BASIC continued until I got my first Mac, when I was a freshman in high school. I wanted to continue to write programs, but the only BASIC I could find was Microsoft BASIC. Even then, I hated Microsoft, so I looked for a better language. I ended up taking some classes at the Rochester Institute of Technology as a high school sophomore. The classes were extremely valuable, but were taught in Pascal, which ain't C but is still much better than BASIC.

During Christmas that year, a friend of my mom's came to visit us. At the time, he worked for Apple. He encouraged me to dig through some of the volumes of Inside Macintosh to learn Macintosh programming. I printed volume 1 out from a HyperCard stack and was soon able to do basic QuickDraw stuff, still using Pascal. By this time, I had a PowerBook 100 and for a few weeks, I would stay up all night working on "ScottPaint", a very weak little paint program. When that was done, I attempted to write an Artificial Intelligence game called "Reality Sucks," but that never got very far.

That summer, I came to Stanford as part of a program they have for high school kids that wanted to know what college was like. During the summer, I learned C and wrote some little Macintosh programs that just played sounds. When I got back home, I started writing a text editor, called Jot. I worked on that for quite a while on my new Duo 210 and it was great to get feedback from people on a local BBS and to have an actual group of testers.

After Jot 1.5.1 came out, I slacked off a bit, under the false impression that school work was more important than programming. I should qualify that by admitting that working hard in high school got me into Stanford. Anyways, during my senior year, I came out with a mess of new programs like MacFolklore, PowerSpaceTabsPlus, HTML Markdown, and eventually HTML Markup. The latter was the first program that really brought me into the shareware business and received lots of attention and feedback.

Since then, I've come out with new versions of most of the above programs. I've also done NetBots and a bunch of other utilities. I'm now back at Stanford (a sophomore as of this writing) and I've had programming internships at Be, Inc. and Xerox Corp. This summer I'll be working at Apple Research Labs.

If you'd like to know anything else about me, feel free to visit my personal home page at http://htc.rit.edu/scott.html or send email to my personal address, klep@cs.stanford.edu

Special Thanks

Many people have helped me with this project and I'd like to take this opportunity to thank as many of them as I can think of. I'd like to thank my dad, Michael Kleper, for raising me on Macs instead of PCs. I'd like to thank Randy Stahl for getting me started with Mac programming. NetBots would not have been possible without the help of Julie Zelenski, my CS advisor and C++ professor, Dominic Giampaulo and Brad Taylor, the programming studs at Be who helped me learn TCP/IP programming, and Michael Trent, author of Simple Sockets. Thanks to Adam Nash for threading and dink list advice. Thanks to Nick Parlante for CS108, the best class at Stanford. Thanks to Rob Baesman and Alan Frindell for some code borrowed from Legend Workshop (mystic bunny, rub my tummy). I'd also like to thank all the registered users of NetBots 1.0, whose support made this version possible through the purchase of CodeWarrior 10/11.

This program was tested by a small number of dedicated beta users. Darien Kruss took it upon himself to send me a complete interface for NetBots, and I implemented as much of it as I could. Early versions of NetBots were all grey windows with black Chicago text. Thanks to Darien, the dialogs are much more elegant. Some of the graphics were done by Dave Laster. Just about everybody contributed something to the program you now have installed. Here are the names of the original beta testers:

I'd also like to thank my mom. Thanks, mom!

Version History

2.0.1 (6/10/97) - Due to a version mixup, the shipping version 2.0 had a problem where it would sometimes have the RegisterBot show up repeatedly. The RegisterBot has been eliminated in version 2.0.1.

2.0 (6/7/97) - Major rewrite! WWWBots, threaded bots, AppleScripts can be sent on success, new Bot Manager, new interface, new preferences, bots are saved on quit, bug fixes, OT native on 68k as well as PowerMac, and much much more.

1.1 (12/24/96) - OpenTransport native on PowerMacs! Totally rewrote the networking code. It's actually asynchronous underneath, but the queue manager currently works linearly. Future versions may allow multiple bots to run at once. The new networking code allows more reasonable timeouts (2 minutes) and also allows you to halt the bot queue without crashing the machine (always a good thing). This version fixes a bug from 1.0 where if you ran the queue before creating any bots, you'd mess things up. It adds support for logging all bot actions to a file, which can be turned off in the preferences dialog. It also adds a floating picture of my head (from 9th grade) to the About Box.

1.0 (07/17/96) - Initial release. Used Simple Sockets for networking, supporting MacTCP only. Had the original three bots - PortBots, PingBots, and FingerBots.

Legal Stuff

NetBots 2.0 is ©opyright 1997, by Scott J. Kleper. You may copy and distribute the SHAREWARE version of NetBots 2.0 as long as you include all the documentation and everything that came with it when you downloaded it. This program is shareware. If you use it, you are obligated to pay for it. See above for payment/registration information.

No warranty is included with this program. Use it at your own risk. There are no known bugs with this program. However, the author is not responsible for any problems caused by it. The user assumes all responsibility for abuse/misuse of this program. You are responsible for your own actions and the author is not responsible for any unethical or criminal actions performed with the aid of NetBots.

This program may be included in online file areas and archives. It may be distributed through user groups and shared with other users. CD-ROM publishers MUST contact me at klephacks@kagi.com before including NetBots 2.0 on a CD-ROM product.

If you would like to review NetBots for an online or traditional magazine, please contact me so that I can see a copy.